home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 49 / Amiga Format CD49 (2000-01-17)(Future Publishing)(GB)(Track 1 of 3)[!][issue 2000-02].iso / -serious- / comms / other / novia / src / novia_mail.c < prev    next >
Text File  |  1999-12-06  |  16KB  |  623 lines
  1. #include <stdlib.h>
  2. #include <pragma/exec_lib.h>
  3. #include <pragma/dos_lib.h>
  4. #include <novia/novia_UserList.h>
  5. #include <novia/novia_PortData.h>
  6. #include <novia/novia_config.h>
  7. #include <novia/novia_vde.h>
  8. #include <novia/novia_mail.h>
  9. #include <novia/novia_subboard.h>
  10. #include <novia/novia_types.h>
  11. #include <novia/novia_misc.h>
  12. #include <novia/novia_message.h>
  13. #include <exec/memory.h>
  14. #include <dos/dos.h>
  15. #include <string.h>
  16. #include <stdio.h>
  17. #include <ctype.h>
  18. #include <time.h>
  19. #include <novia/novia_funcs.h>
  20. #include <pragma/noviasys_lib.h>
  21.  
  22. #define PORTTYPE_MAIN 1
  23. #define PORTTYPE_CLIENT 0
  24.  
  25. void SaveMail(long UserID,long MailID);
  26. void MailVerify(long UserID);
  27. void AddMail(long UserID);
  28. void ShowMail(long UserID,long MailID);
  29. void ReadSubboard(struct Item *item,char *path);
  30.  
  31. void SaveMail(long UserID,long MailID)
  32. {
  33. }
  34.  
  35. void MailVerify(long UserID)
  36. {
  37.     struct PortData *cport=(PortData *)FindTask(NULL)->tc_UserData;
  38.     if (cport)
  39.     {
  40.         BPTR mulder;
  41.         char buffer[200],Quit=FALSE,y;
  42.         char filename[50];
  43.         char username[100];
  44.         char subject[100];
  45.         char counter,rebuild=TRUE,lastMail=FALSE;
  46.         char nostdcmd;
  47.         long entrys=0,MailID=1,result;
  48.         ULONG cmdid;
  49.         sprintf(filename,"%s%d/MailHead",cport->sysdirs->userdir,UserID);
  50.         mulder=Open(filename,MODE_OLDFILE);
  51.         if (mulder)
  52.         {
  53.             Read(mulder,&entrys,4);
  54.             Close(mulder);
  55.         }
  56.         CLS();
  57.         while (Quit==FALSE && !cport->ProgramClose && cport->network.online)
  58.         {
  59.             if (rebuild==TRUE)
  60.             {
  61.                 LF();
  62.                 if (entrys)
  63.                 {
  64.                     for (counter=0;(counter+MailID<=entrys && counter<20 && rebuild==TRUE);counter++)
  65.                     {
  66.                         mulder=Open(filename,MODE_OLDFILE);
  67.                         if (mulder)
  68.                         {
  69.                             Seek(mulder,((counter+MailID-1)*(sizeof(Mail)))+84,OFFSET_BEGINNING);
  70.                             Read(mulder,subject,80);
  71.                             Read(mulder,username,80);
  72.                             sprintf(buffer,"%4d %20s %s",counter+MailID,username,subject);
  73.                             LF();Writeio(buffer,-1);
  74.                             Close(mulder);
  75.                         }
  76.                     }
  77.                 }
  78.                 else
  79.                     ioprintf("Mailbox is empty.\n");
  80.                 LF();
  81.                 rebuild=FALSE;
  82.             }
  83.             LF();Writeio("Quit, Scan, Edit, Read # :> ",-1);
  84.             Getstring(buffer,0,50,BUFFERED,0);
  85.             StrToLong(buffer,&result);
  86.             GetArg(buffer);
  87.             nostdcmd=TRUE;
  88.             switch ((cmdid=GetCommandID(cport->argstring[0])))
  89.             {
  90.                 case CMD_QUIT:
  91.                     Quit=TRUE;
  92.                     nostdcmd=FALSE;
  93.                     break;
  94.                 case CMD_SAVE:
  95.                     Getlong((ULONG *)&result,0,50,0,0);
  96.                     if (result>0 && result<=entrys)
  97.                     {
  98.                         if (result>0 && result<=entrys)
  99.                         {
  100.                             MailID=result;
  101.                                 rebuild=TRUE;
  102.                         }
  103.                         if (result<0)
  104.                         {
  105.                             if ((MailID+result)>0)MailID=MailID+result;
  106.                             else MailID=1;
  107.                             rebuild=TRUE;
  108.                         }
  109.                     }
  110.                     nostdcmd=FALSE;
  111.                     break;
  112.                 case CMD_KILL: case CMD_DEL:
  113.                     nostdcmd=FALSE;
  114.                     break;
  115.             }
  116.             if (nostdcmd)
  117.             {    
  118.                 if (!cmdid)
  119.                 {
  120.                     if (result)
  121.                     {
  122.                         ioprintf("result: %d\n",result);
  123.                         if (result<=entrys)
  124.                         {
  125.                             MailID=result;
  126.                             CLS();ShowMail(UserID,MailID);
  127.                             if (MailID<entrys)
  128.                             {
  129.                                 MailID++;
  130.                                 lastMail=FALSE;
  131.                             }
  132.                             else
  133.                                 lastMail=TRUE;
  134.                         }
  135.                         else
  136.                             ioprintf("c3invalid item c7%d.\n",result);
  137.                     }
  138.                     else
  139.                     {
  140.                         if (*cport->argstring[0]=='0')
  141.                         {
  142.                             ioprintf("c3invalid item c7%d.\n",result);                            
  143.                         }
  144.                         else
  145.                         {
  146.                             if (strlen(cport->argstring[0])==0)
  147.                             {
  148.                                 if (lastMail==FALSE)
  149.                                 {
  150.                                     CLS();ShowMail(UserID,MailID);
  151.                                     if (MailID<entrys)
  152.                                     {
  153.                                         MailID++;
  154.                                         lastMail=FALSE;
  155.                                     }
  156.                                     else
  157.                                         lastMail=TRUE;
  158.                                 }
  159.                                 else
  160.                                     ioprintf("\nNo more Mails!\n");
  161.                             }
  162.                             else
  163.                                 ioprintf("\n%s: Unknown command\n",cport->argstring[0]);
  164.                         }
  165.                     }
  166.                 }
  167.                 else
  168.                 {
  169.                     if (!StdCommand(cmdid));
  170.                         ioprintf("\n%s: Unknown command\n",cport->argstring[0]);
  171.                 }
  172.             }
  173.         }
  174.     }
  175. }
  176.     
  177. void AddMail(long UserID)
  178. {
  179.     struct PortData *cport=(PortData *)FindTask(NULL)->tc_UserData;
  180.     if (cport)
  181.     {
  182.         Mail brief;
  183.         LONG size;
  184.         APTR init;
  185.         BPTR mulder=NULL;
  186.         BPTR mulder2=NULL;
  187.         char *text,bool,Quit,buffer[80];
  188.         long touser=0;
  189.         VisualEditor("");
  190.         LF();Writeio("if you are finish with writing, then press return",-1);
  191.         WaitKey(0);
  192.         mulder=Open("ram:text",MODE_OLDFILE);
  193.         if (mulder==0)return;
  194.         brief.IPNumber=cport->LocalUser.IDNumber;
  195.         brief.FromUser=cport->LocalUser.IDNumber;
  196.         brief.MailType=MAILTYPE_NOVIA;
  197.         strcpy(brief.From,cport->LocalUser.Handle);
  198.         strcpy(brief.FromRealName,cport->LocalUser.RealName);
  199.         LF();Writeio("From    : ",-1);
  200.         Writeio(brief.From,-1);
  201.         while (touser==0)
  202.         {
  203.             LF();Writeio("To      : ",-1);
  204.             Getstring(buffer,0,50,0,0);
  205.             touser=SearchUser(buffer);
  206.         }
  207.         LoadUser(&cport->EditUser,touser);
  208.         strcpy(brief.To,cport->EditUser.Handle);
  209.         strcpy(brief.ToRealName,cport->EditUser.RealName);
  210.         brief.ToUser=touser;
  211.         LF();Writeio("Subject :",-1);
  212.         Getstring(buffer,0,50,0,0);
  213.         strcpy(brief.Subject,buffer);
  214.         LF();Writeio("Do you write anonymous ? [No]",-1);
  215.         if (Yesno(FALSE,0)==TRUE)
  216.         {
  217.             Quit=FALSE;
  218.             while (!Quit && !cport->ProgramClose && cport->network.online)
  219.             {
  220.                 LF();Writeio("Alias   :",-1);
  221.                 Getstring(buffer,0,50,0,0);
  222.                 if (strlen(buffer)>0)Quit=TRUE;
  223.             }
  224.             strcpy(brief.Alias,buffer);
  225.             brief.AnonymousMail=TRUE;
  226.         }
  227.         else
  228.         {
  229.             brief.AnonymousMail=FALSE;
  230.             brief.Alias[0]=0;
  231.             brief.AnonymousMail=0;
  232.         }
  233.         brief.NoEdit=0;
  234.         brief.MailListMail=0;
  235.         brief.Receipt=0;
  236.         brief.Return=0;
  237.         brief.FileMail=0;
  238.         brief.Copy=0;
  239.         brief.LogMail=0;
  240.         brief.LogID=0;
  241.         brief.MailListID=0;
  242.         brief.ForwardEntrys=0;
  243.         brief.first_Forward=0;
  244.         brief.last_Forward=0;
  245.     
  246.         Seek(mulder,0,OFFSET_END);
  247.         brief.length=Seek(mulder,0,OFFSET_END);
  248.         if (brief.length==0)return;
  249.         sprintf(buffer,"%s%d/MailData",cport->sysdirs->userdir,touser);
  250.         mulder2=Open(buffer,MODE_READWRITE);
  251.         if (mulder2==0)
  252.         {
  253.             mulder2=Open(buffer,MODE_NEWFILE);
  254.             if (mulder2==0)return;
  255.             brief.Seek=0;
  256.         }
  257.         else
  258.         {
  259.             Seek(mulder2,0,OFFSET_END);
  260.             brief.Seek=Seek(mulder2,0,OFFSET_END);
  261.         }
  262.         text=AllocVec(brief.length,MEMF_ANY);
  263.         if (text==0)
  264.         {
  265.             Close(mulder);
  266.             Close(mulder2);
  267.             return;
  268.         }
  269.         Seek(mulder,0,OFFSET_BEGINNING);
  270.         Read(mulder,text,brief.length);
  271.         Close(mulder);
  272.         Write(mulder2,text,brief.length);
  273.         Close(mulder2);
  274.         FreeVec(text);
  275.         sprintf(buffer,"%s%d/MailHead",cport->sysdirs->userdir,touser);
  276.         mulder=Open(buffer,MODE_READWRITE);
  277.         if (mulder==NULL)
  278.         {
  279.             mulder=Open(buffer,MODE_NEWFILE);
  280.             if (mulder==NULL)return;
  281.             init=AllocVec(20,MEMF_ANY|MEMF_CLEAR);
  282.             if (init==0)
  283.             {
  284.                 Close(mulder);
  285.                 return;
  286.             }
  287.             Write(mulder,init,20);
  288.             FreeVec(init);
  289.         }
  290.         else
  291.         {
  292.             Seek(mulder,0,OFFSET_END);
  293.             if (Seek(mulder,0,OFFSET_END)>=20)
  294.             {
  295.                 Seek(mulder,0,OFFSET_BEGINNING);
  296.                 Read(mulder,&brief.IDNumber,4);
  297.                 brief.IDNumber++;
  298.             }
  299.             else
  300.             {
  301.                 brief.IDNumber=1;
  302.                 init=AllocVec(20,MEMF_ANY|MEMF_CLEAR);
  303.                 if (init==0)
  304.                 {
  305.                     Close(mulder);
  306.                     return;
  307.                 }
  308.                 Seek(mulder,0,OFFSET_BEGINNING);
  309.                 Write(mulder,init,20);
  310.                 FreeVec(init);
  311.             }
  312.         }
  313.         Seek(mulder,0,OFFSET_BEGINNING);
  314.         Write(mulder,&brief.IDNumber,4);
  315.         Seek(mulder,20+((brief.IDNumber-1)*sizeof(Mail)),OFFSET_BEGINNING);
  316.         Write(mulder,&brief,sizeof(Mail));
  317.         Close(mulder);
  318.     }
  319. }
  320.  
  321.  
  322. void ShowMail(long UserID,long MailID)
  323. {
  324.     struct PortData *cport=(PortData *)FindTask(NULL)->tc_UserData;
  325.     if (cport)
  326.     {
  327.         Mail brief;
  328.         long items;
  329.         char buffer[200];
  330.         BPTR mulder;
  331.         BOOL flag=FALSE;
  332.         sprintf(buffer,"%s%d/MailHead",cport->sysdirs->userdir,UserID);
  333.         mulder=Open(buffer,MODE_OLDFILE);
  334.         if (mulder==NULL)return;
  335.         Seek(mulder,0,OFFSET_END);
  336.         if (Seek(mulder,0,OFFSET_END)<(sizeof(Mail)*MailID))
  337.         {
  338.             Close(mulder);
  339.             return;
  340.         }
  341.         Seek(mulder,0,OFFSET_BEGINNING);
  342.         Read(mulder,&items,4);
  343.         Seek(mulder,20+((MailID-1)*sizeof(Mail)),OFFSET_BEGINNING);
  344.         Read(mulder,&brief,sizeof(Mail));
  345.         Close(mulder);
  346.         if (brief.MailType==MAILTYPE_NOVIA)LoadUser(&cport->EditUser,brief.FromUser);
  347.         ioprintf("z4c7Item    :z0c3 (%d of %d) - c2SerialID: %010d.%010d\n",MailID,items,brief.IDNumber,brief.IPNumber);
  348.         ioprintf("z4c7Subject :z0c7 %s\n",brief.Subject);
  349.         ioprintf("z4c7From    :z0c3 ");
  350.         if (cport->LocalUser.Flag_trace_anounym==TRUE | cport->LocalUser.Flag_supervisor==TRUE)flag=TRUE;
  351.         if (brief.AnonymousMail==TRUE)
  352.         {
  353.             if (flag==TRUE)Writeio("",-1);
  354.             Writeio(brief.Alias,-1);
  355.             if (flag==TRUE)Writeio("",-1);
  356.         }
  357.         if (brief.AnonymousMail==FALSE | flag==TRUE)
  358.         {
  359.             Writeio("",-1);
  360.             Writeio(brief.From,-1);
  361.             if (brief.MailType==MAILTYPE_NOVIA)
  362.             {
  363.                 Writeio(" (",2);
  364.                 Writelong(brief.FromUser);
  365.             }
  366.             if (cport->EditUser.PRealName==FALSE | cport->LocalUser.Flag_supervisor==TRUE | brief.MailType!=MAILTYPE_NOVIA)
  367.             {
  368.                 Writeio(", ",2);
  369.                 Writeio(brief.FromRealName,-1);
  370.             }
  371.         }
  372.         Writeio(")",2);
  373.         LF();
  374.         Writeio("To      : ",-1);
  375.         Writeio(brief.To,-1);
  376.         if (brief.ToUser>0)
  377.         {
  378.             Writeio(", ",-1);
  379.             Writelong(brief.ToUser);
  380.             if (brief.MailType==MAILTYPE_NOVIA)
  381.             {
  382.                 Writeio(", ",2);
  383.                 Writelong(brief.FromUser);
  384.             }
  385.         }
  386.         LF();
  387.         ioprintf("Send    : 00:00\n");
  388.         ioprintf("Received: 00:00\n");
  389.         LF();
  390.         sprintf(buffer,"%s%d/MailData",cport->sysdirs->userdir,UserID);
  391.         ShowPart(buffer,brief.Seek,brief.length);
  392.         LF();
  393.     }
  394. }
  395.  
  396. void ReadSubboard(struct Item *item,char *path)
  397. {
  398.     struct PortData *cport=(PortData *)FindTask(NULL)->tc_UserData;
  399.     if (cport)
  400.     {
  401.         BPTR data_mulder=NULL;
  402.         BPTR index_mulder=NULL;
  403.         char buffer[256];
  404.         struct Reply *reply=NULL;
  405.         char quit=FALSE;
  406.         char readnew=TRUE;
  407.         ULONG ulong=0;
  408.         ULONG cmdid=0;
  409.         ULONG maxreplys=0;
  410.         ULONG replycounter=0;
  411.         LONG currentreply=0;
  412.         char nostdcmd=TRUE;
  413.         char readmore=TRUE;
  414.         char *buffer2;
  415.         char *select=AllocVec(item->replys,MEMF_ANY|MEMF_CLEAR);
  416.         do
  417.         {
  418.             if (readnew)
  419.             {
  420.                 sprintf(buffer,"%s/data/%s.replys",path,item->itemheader.Path);
  421.                 if (index_mulder=Open(buffer,MODE_OLDFILE))
  422.                 {
  423.                     Seek(index_mulder,0,OFFSET_END);
  424.                     if (ulong=Seek(index_mulder,0,OFFSET_BEGINNING)/sizeof(Reply))
  425.                     {
  426.                         if (ulong+1>maxreplys)
  427.                         {
  428.                             if (reply)FreeVec(reply);
  429.                             replycounter=ulong;
  430.                             if (reply=AllocVec((replycounter+10)*sizeof(Reply),MEMF_ANY))
  431.                             {
  432.                                 maxreplys=replycounter+10;
  433.                             }
  434.                             else
  435.                             {
  436.                                 maxreplys=0;
  437.                                 replycounter=0;
  438.                                 ioprintf("\nCan't alloc mem for replystructure");
  439.                                 quit=TRUE;
  440.                             }
  441.                         }
  442.                         if (reply)Read(index_mulder,reply,ulong*sizeof(Reply));
  443.                     }
  444.                     else
  445.                     {
  446.                         ioprintf("no more items\n");
  447.                     }
  448.                     Close(index_mulder);
  449.                 }
  450.                 readnew=FALSE;
  451.             }
  452.             if (readmore)
  453.             {
  454.                 CLS();
  455.                 if (!currentreply)
  456.                 {
  457.                     ioprintf("\nz4c7Item    :z0c3 (%d, %d replys) - c2SerialID: %05d.%05d.00001\n",item->itemheader.IDNumber,item->replys+1,item->DirIP,item->itemheader.IPNumber);
  458.                     ioprintf("z4c7Subject :z0c7 %s\n",item->itemheader.Title);
  459.                     ioprintf("z4c7From    :z0c3 %s (%u)\n",item->From,item->FromUser);
  460.                     ioprintf("z4c7To      :z0c3 %s (%u)\n",item->To,item->ToUser);
  461.                     DateToString(buffer,&item->itemheader.LastChange,0);
  462.                     ioprintf("z4c7on      :z0c3 %s\n",buffer);
  463.                     sprintf(buffer,"%s/data/%s.text",path,item->itemheader.Path);
  464.                     ShowPart(buffer,item->seek,item->length);
  465.                 }
  466.                 else
  467.                 {
  468.                     ioprintf("\nz4c7Reply   :z0c3 (%d of %d) - c2SerialID: %05d.%05d.%05d\n",currentreply+1,item->replys+1,item->DirIP,item->itemheader.IPNumber,currentreply+1);
  469.                     ioprintf("z4c7From    :z0c3 %s (%u)\n",reply[currentreply-1].From,reply[currentreply-1].FromUser);
  470.                     ioprintf("z4c7To      :z0c3 %s (%u)\n",reply[currentreply-1].To,reply[currentreply-1].ToUser);
  471.                     DateToString(buffer,&reply[currentreply-1].LastChange,0);
  472.                     ioprintf("z4c7on      :z0c3 %s\n",buffer);
  473.                     sprintf(buffer,"%s/data/%s.text",path,item->itemheader.Path);
  474.                     ShowPart(buffer,reply[currentreply-1].seek,reply[currentreply-1].length);
  475.                 }
  476.                 readmore=FALSE;
  477.             }
  478.             ioprintf("\ncmd:>");
  479.             Getstring(buffer,0,50,BUFFERED,0);
  480.             GetArg(buffer);
  481.             cmdid=GetCommandID(cport->argstring[0]);
  482.             nostdcmd=TRUE;
  483.             if (!cmdid)
  484.             {
  485.                 if (currentreply<replycounter)
  486.                 {
  487.                     currentreply++;
  488.                     readmore=TRUE;
  489.                 }
  490.                 else
  491.                     quit=TRUE;
  492.             }
  493.             else
  494.             switch(cmdid)
  495.             {
  496.                 case CMD_QUIT: case CMD_PARRENT:
  497.                     quit=TRUE;
  498.                     nostdcmd=FALSE;
  499.                     break;
  500.                 case CMD_REPLY:
  501.                     ioprintf("reply\n");
  502.                     if (replycounter+1>maxreplys)
  503.                     {
  504.                         if (reply)FreeVec(reply);
  505.                         if (reply=AllocVec((replycounter+10)*sizeof(Reply),MEMF_ANY))
  506.                         {
  507.                             ioprintf("reply1\n");
  508.                             maxreplys=replycounter+10;
  509.                         }
  510.                         else
  511.                         {
  512.                             ioprintf("\nCan't alloc mem for replystructure");
  513.                             quit=TRUE;
  514.                         }
  515.                     }
  516.                     ioprintf("replycounter %d, maxreplys: %d",replycounter,maxreplys);
  517.                     if (replycounter+1<maxreplys)
  518.                     {
  519.                         ioprintf("reply2\n");
  520.                         ClearMemQuick(&reply[replycounter],sizeof(Reply));
  521.                         ioprintf("\nc7ToUser:> ");
  522.                         Getstring(reply[replycounter].To,0,50,BUFFERED,0);
  523.                         if (!(ulong=SearchUser(reply[replycounter].To)))
  524.                             StrToLong(reply[replycounter].To,(LONG *)&ulong);
  525.                         if (ulong>0 && ulong<=cport->UL.UserEntrys)
  526.                         {
  527.                             reply[replycounter].ToUser=ulong;
  528.                             if (VisualEditor("ram:temp"))
  529.                             {
  530.                                 if (data_mulder=Open("ram:temp",MODE_OLDFILE))
  531.                                 {
  532.                                     Seek(data_mulder,0,OFFSET_END);
  533.                                     if (ulong=Seek(data_mulder,0,OFFSET_BEGINNING))
  534.                                     {
  535.                                         if (buffer2=AllocVec(ulong+1,MEMF_ANY))
  536.                                             Read(data_mulder,buffer2,ulong);
  537.                                         Close(data_mulder);
  538.                                         if (buffer2)
  539.                                         {
  540.                                             sprintf(buffer,"%s/data/%s.replys",path,item->itemheader.Path);
  541.                                             if (index_mulder=Open(buffer,MODE_READWRITE))
  542.                                             {
  543.                                                 sprintf(buffer,"%s/data/%s.text",path,item->itemheader.Path);
  544.                                                 if (data_mulder=Open(buffer,MODE_READWRITE))
  545.                                                 {
  546.                                                     Seek(data_mulder,0,OFFSET_END);
  547.                                                     reply[replycounter].seek=Seek(data_mulder,0,OFFSET_END);
  548.                                                     reply[replycounter].length=ulong;
  549.                                                     Write(data_mulder,buffer2,ulong);
  550.                                                     Close(data_mulder);
  551.                                                 }
  552.     
  553.                                                 /*** Adding Username & ID of Creater ***/
  554.         
  555.                                                 reply[replycounter].FromUser=cport->LocalUser.IDNumber;
  556.                                                 strcpy(reply[replycounter].From,cport->LocalUser.Handle);
  557.                                                 strcpy(reply[replycounter].FromRealName,cport->LocalUser.RealName);
  558.                                                 GetTime(&reply[replycounter].CreateDate);
  559.                                                 GetTime(&reply[replycounter].LastChange);
  560.         
  561.                                                 /*** End of .data-file is the offset for new subboard-structure ***/
  562.         
  563.                                                 Seek(index_mulder,0,OFFSET_END);
  564.                                                 Write(index_mulder,&reply[replycounter],sizeof(Reply));
  565.                                                 replycounter++;
  566.                                                 Close(index_mulder);
  567.                                             }
  568.                                             else
  569.                                             {
  570.                                                 ulong=(LONG)IoErr();
  571.                                                 Fault((LONG)ulong,NULL,buffer,FAULT_MAX);
  572.                                                 ioprintf("\nCan't open %s. DOS-Error  %d: %s\n",path,ulong,buffer);
  573.                                             }
  574.                                             FreeVec(buffer2);
  575.                                         }
  576.                                         else
  577.                                         {
  578.                                             ioprintf("Can't alloc mem for Reply-Text");
  579.                                         }
  580.                                     }
  581.                                 }
  582.                                 else
  583.                                 {
  584.                                     ulong=(LONG)IoErr();
  585.                                     Fault((LONG)ulong,NULL,buffer,FAULT_MAX);
  586.                                     ioprintf("\nCan't open %s. DOS-Error  %d: %s\n",path,ulong,buffer);
  587.                                 }
  588.                             }
  589.                         }
  590.                     }
  591.                     nostdcmd=FALSE;
  592.                     break;
  593.             }
  594.             if (nostdcmd)
  595.             {
  596.                 if (strlen(cport->argstring[0]))
  597.                 {
  598.                     if (*cport->argstring[0]!='*')
  599.                     {
  600.                         StrToLong(cport->argstring[0],(long *)&ulong);ulong--;
  601.                         if (ulong>=0 && ulong<replycounter)
  602.                         {
  603.                             currentreply=ulong;
  604.                             readmore=TRUE;
  605.                         }
  606.                         else
  607.                         {
  608.                             if (!StdCommand(cmdid));
  609.                                 ioprintf("\n%s: Unknown command\n",cport->argstring[0]);
  610.                             readmore=FALSE;
  611.                         }
  612.                     }
  613.                 }
  614.             }
  615.         }
  616.         while (!quit && !cport->ProgramClose && cport->network.online);
  617.         if (select)FreeVec(select);
  618.         if (reply)FreeVec(reply);
  619.     }
  620. }
  621.  
  622.  
  623.